package com.spzx.product.service.impl;

import com.alibaba.nacos.common.utils.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.spzx.common.core.utils.bean.BeanUtils;
import com.spzx.product.domain.Category;
import com.spzx.product.mapper.CategoryMapper;
import com.spzx.product.service.ICategoryService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.spzx.product.vo.CategoryVo;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 * 商品分类 服务实现类
 * </p>
 *
 * @author Login
 * @since 2025-07-17
 */
@Service
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements ICategoryService {

    @Override
    public List<Category> treeSelect(Long id) {
        // 1. 查询直接子节点
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Category::getParentId, id); //根据 传进来的Long id 的id 和ParentId 对比，查找相等的。会得到queryWrapper。

        List<Category> categoryList = baseMapper.selectList(queryWrapper);// 将queryWrappers数据存入列表中
        // 2. 递归处理每个子节点
        if(!CollectionUtils.isEmpty(categoryList)){
            for(Category category : categoryList){
                // 递归查询当前节点的子节点
                category.setHasChildren(treeSelect(category.getId()).size() > 0);  //递归，调用treeSelect方法本身。获取当前节点的ID，检查返回列表的大小是否大于0
            }
        }
        return categoryList;

    }

    @Override
    public List<Long> getAllCategoryList(Long categoryId) {
        //根据三级类别id(categoryId)查询所有父级类别，并组装成List<Long>

        //下面两排就是获取二级类别
        Category category = baseMapper.selectById(categoryId);  // categoryId--> 3  category-->手机  手机的父类id：  parentId -> 2   手机通信
        Long parentId = category.getParentId();
        //获取一级类别
        Category categoryParent = baseMapper.selectById(parentId); //parentId -> 2  categoryParent ->手机通讯   手机通信的父类id： topId ->  1
        Long topId = categoryParent.getParentId();

        List<Long> ids = new ArrayList<>();   //创建列表 ids  （是空的）
        ids.add(topId);
        ids.add(parentId);
        ids.add(categoryId);
        return ids;
    }

    @Override
    public List<CategoryVo> getLevelOneCategory() {
        //查询所有一级分类
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Category::getParentId,0);
        List<Category> allCategoryList = baseMapper.selectList(queryWrapper);

        //这段代码的作用是将从数据库中查询到的一级分类数据（List<Category>）转换为前端展示用的 VO（View Object）对象列表（List<CategoryVo>）。
        // 转为vo
        //使用 Java Stream API 对 allCategoryList（一个 Category 对象的列表）进行流式处理。map 方法表示对流中的每一个 Category 元素进行转换。
        return allCategoryList.stream().map(item -> {
            //创建一个新的 CategoryVo 对象，用于封装前端需要展示的数据。
            CategoryVo categoryVo = new CategoryVo();
            //使用 BeanUtils.copyProperties 方法将 Category 对象中的属性值拷贝到 CategoryVo 对象中。常用于数据从数据库实体对象转换为前端展示对象。
            BeanUtils.copyProperties(item,categoryVo);
            //返回转换后的 categoryVo 对象，作为当前 map 操作的结果。
            return categoryVo;
            //将流处理后的每个 categoryVo 收集为一个 List，最终返回 List<CategoryVo> 类型的结果。
        }).collect(Collectors.toList());
    }

    @Override
    public List<CategoryVo> tree() {
        //查询所有的分类   todo 记住下面的这个方法！！！！！！！
        List<Category> categoryList = baseMapper.selectList(null);
        //转为vo
        List<CategoryVo> categoryVoList = categoryList.stream().map(category -> {
            CategoryVo categoryVo = new CategoryVo();
            BeanUtils.copyProperties(category, categoryVo);
            return categoryVo;
        }).toList();
        //构建树 型结构
        return buildTree(categoryVoList);
    }

    /**
     * 使用递归方法建分类树
     * @param categoryVoList
     * @return
     */
    private List<CategoryVo> buildTree(List<CategoryVo> categoryVoList) {
        //创建树形结构
        List<CategoryVo> trees = new ArrayList<>();
        //遍历所有节点
        for (CategoryVo categoryVo : categoryVoList){
            //判断当前节点是否是根节点
            if(categoryVo.getParentId().longValue()==0){
                //添加到树形结构中
                findAndAddChildren(categoryVo,categoryVoList);
                //添加到树形结构中
                trees.add(categoryVo);
            }
        }
        return trees;
    }

    /**
     * 在categoryVoList中找到categoryVo的子节点，并组装到categoryVo中
     * @param categoryVo
     * @param categoryVoList
     * @return 返回组装好的categoryVo节点
     */
    private void findAndAddChildren(CategoryVo categoryVo, List<CategoryVo> categoryVoList) {
        //遍历所有节点
        for (CategoryVo vo : categoryVoList) {
            //判断是否是categoryVo的子节点
            if(vo.getParentId().longValue()==categoryVo.getId().longValue()){
                //在categoryList中找到categoryVo的子节点
                findAndAddChildren(vo,categoryVoList);
                //并添加到categoryVo中
                categoryVo.getChildren().add(vo);
            }
        }

    }


}
